5.02. Справочник по модулю Turtle

ДЛЯ НОВИЧКОВНЕ ОБЯЗАТЕЛЬНОВ РАЗРАБОТКЕ

Разработчику Архитектору

Справочник по модулю Turtle

1. Введение и основные классы модуля `turtle`

Модуль turtle входит в стандартную библиотеку Python и реализует графический интерфейс на основе концепции «черепашьей графики» — метода обучения программированию через управление виртуальной «черепашкой», которая перемещается по экрану, оставляя след.

Модуль предоставляет два уровня API:

Процедурный интерфейс — функции, работающие с одной (по умолчанию) черепашкой. Подходит для обучения и простых программ.
Объектно-ориентированный интерфейс — явное создание экземпляров классов Turtle, Screen, TurtleScreen, Shape, Vec2D. Подходит для сложных приложений, нескольких черепашек, интеграции в tkinter.

Основные классы

1. `turtle.Turtle`

Объект, представляющий черепашку. Каждая черепашка — независимый объект, обладающий своим положением, направлением, цветом, шириной пера и другими атрибутами.

Конструктор:

t = turtle.Turtle(shape='classic', visible=True)

shape — строка, имя формы: 'arrow', 'turtle', 'circle', 'square', 'triangle', 'classic'.
visible — флаг видимости при создании.

2. `turtle.Screen`

Представляет графическое окно (холст), в котором происходят все действия черепашек. Инициирует tkinter.Tk при создании.

Конструктор (обычно вызывается неявно):

screen = turtle.Screen()

Допустимо только одно окно Screen в процессе — последующие вызовы Screen() возвращают тот же объект.

3. `turtle.TurtleScreen`

Низкоуровневый класс — холст, встроенный в существующий tkinter.Canvas. Используется для интеграции в GUI-приложения.

Пример:

import tkinter as tk
import turtle

root = tk.Tk()
canvas = tk.Canvas(root, width=600, height=400)
canvas.pack()

ts = turtle.TurtleScreen(canvas)
t = turtle.RawTurtle(ts)

4. `turtle.RawTurtle`

Черепашка без привязки к глобальному окну. Используется с TurtleScreen для встраивания в tkinter.

5. `turtle.Vec2D`

Класс для двумерных векторов. Все координаты возвращаются/принимаются как (x, y) — на самом деле — экземпляры Vec2D, поддерживающие арифметику: +, -, * (скалярное и векторное), abs() (длина), .rotate(angle).

6. `turtle.Shape`

Описывает пользовательскую форму черепашки или штамп (stamp). Используется для регистрации новых фигур через Screen.register_shape().

2. Функции управления движением

Все движения черепашки происходят в координатной системе с центром в (0, 0), осью X — вправо, осью Y — вверх. По умолчанию черепашка смотрит вправо (направление 0°). Углы измеряются в градусах (можно переключить в радианы через turtle.radians()).

Перечисленные ниже функции доступны как в процедурном (turtle.forward()), так и в объектно-ориентированном (t.forward()) стиле.

1. Линейное перемещение

Функция	Параметры	Описание
`forward(distance)` `fd(distance)`	`distance: float` — расстояние в пикселях	Перемещает черепашку вперёд на указанное расстояние. Если `distance < 0` — движение назад.
`backward(distance)` `bk(distance)` `back(distance)`	`distance: float`	Перемещает черепашку назад на указанное расстояние. Эквивалент `forward(-distance)`.
`goto(x, y=None)` `setpos(x, y=None)` `setposition(x, y=None)`	`x: float	tuple[float, float]`,` y: float \| None`
`setx(x)`	`x: float`	Устанавливает X-координату, сохраняя Y.
`sety(y)`	`y: float`	Устанавливает Y-координату, сохраняя X.

Примечание: при перемещении с опущенным пером (penup()) след не рисуется.

2. Повороты

Функция	Параметры	Описание
`right(angle)` `rt(angle)`	`angle: float`	Поворачивает черепашку по часовой стрелке на `angle` градусов.
`left(angle)` `lt(angle)`	`angle: float`	Поворачивает черепашку против часовой стрелки на `angle` градусов.
`setheading(to_angle)` `seth(to_angle)`	`to_angle: float`	Устанавливает абсолютное направление (в градусах): `0` — вправо, `90` — вверх, `180` — влево, `270` — вниз.
`towards(x, y=None)`	`x, y: float \| tuple`	Возвращает угол (в градусах) от текущей позиции черепашки к точке `(x, y)`. Полезно для наведения.
`heading()`	—	Возвращает текущее направление черепашки в градусах (вещественное число).

3. Криволинейное движение

Функция	Параметры	Описание
`circle(radius, extent=None, steps=None)`	`radius: float` — радиус, `extent: float \| None` — угол дуги в градусах, `steps: int \| None` — количество сторон для аппроксимации	Рисует дугу окружности: – `radius > 0` — центр слева от направления движения; – `radius < 0` — центр справа. Если `extent` не указан — полная окружность (360°). Если `steps` задан — окружность аппроксимируется правильным многоугольником с `steps` сторонами (полезно для рисования многоугольников).
`dot(size=None, color=None)`	`size: int \| None` — диаметр точки, `color: str \| tuple \| None` — цвет	Рисует закрашенный круг с центром в текущей позиции. Если `size` не указан — используется `max(pensize + 4, 2 * pensize)`.
`stamp()`	—	Оставляет «штамп» текущей формы черепашки в текущей позиции. Возвращает ID штампа (целое число).
`clearstamp(stampid)`	`stampid: int`	Удаляет штамп с указанным ID.
`clearstamps(n=None)`	`n: int \| None`	Удаляет `n` последних штампов (`n > 0`), первых (`n < 0`), или все (`n=None` или `0`).

4. Ограничение движения

Функция	Параметры	Описание
`distance(x, y=None)`	`x, y: float \| tuple \| Turtle`	Возвращает евклидово расстояние от черепашки до точки `(x, y)` или до другой черепашки.
`xcor()`	—	Возвращает X-координату текущей позиции.
`ycor()`	—	Возвращает Y-координату текущей позиции.
`pos()` `position()`	—	Возвращает `Vec2D(x, y)`.
`speed(s)`	`s: int \| str`	Устанавливает скорость анимации. Допустимые значения: – `'fastest'` / `0` — без анимации, – `'fast'` / `10`, `'normal'` / `6`, `'slow'` / `3`, `'slowest'` / `1`, – числа от 1 до 10 — градации скорости.

Особенности `circle()` — ключевая функция

Функция circle() — универсальный инструмент для рисования не только окружностей, но и правильных многоугольников, дуг, спиралей.

Примеры:

t.circle(50)               # полная окружность, радиус 50
t.circle(50, 180)          # полукруг (верхняя дуга, если смотрит вправо)
t.circle(-50, 90)          # четверть окружности вниз (центр справа)
t.circle(100, steps=3)     # равносторонний треугольник (аппроксимация)
t.circle(100, steps=4)     # квадрат
t.circle(100, steps=6)     # правильный шестиугольник

При steps=N черепашка проходит N шагов, поворачивая на 360/N градусов после каждого — получается правильный N-угольник, вписанный в окружность радиуса radius.

3. Управление пером и состоянием черепашки

Перо черепашки — виртуальный инструмент, оставляющий след при движении. Его состояние включает: опущено/поднято, цвет, толщину, видимость следа, режим заливки.

1. Основные функции управления пером

Функция	Параметры	Описание
`penup()` `pu()` `up()`	—	Поднимает перо: последующие перемещения не оставляют след.
`pendown()` `pd()` `down()`	—	Опускает перо: перемещения рисуют линии.
`pencolor(*args)`	`*args: str \| tuple \| int` — цвет	Устанавливает цвет пера. Поддерживает: – строковые имена: `'red'`, `'#FF5733'`, `'rgb(255,87,51)'`; – кортежи: `(r, g, b)` в режиме `colormode(255)` или `(r, g, b)` ∈ [0, 1] в `colormode(1.0)`; – три отдельных аргумента: `pencolor(r, g, b)`. Без аргументов — возвращает текущий цвет (`str` или `tuple`).
`pensize(width=None)` `width(width=None)`	`width: int \| float \| None`	Устанавливает толщину пера в пикселях. Без аргумента — возвращает текущую толщину. Минимум — `1`.
`isdown()`	—	Возвращает `True`, если перо опущено.

2. Расширенное управление пером через `pen()`

Функция pen() позволяет читать и устанавливать все атрибуты пера через словарь.

Чтение:

attrs = t.pen()
# {
#   'pendown': True,
#   'pencolor': 'black',
#   'pensize': 1,
#   'fillcolor': 'black',
#   'filling': False,
#   'speed': 3,
#   'resizemode': 'noresize',
#   'stretchfactor': (1.0, 1.0),
#   'outline': 1,
#   'tilt': 0.0
# }

Установка:

t.pen(pendown=False, pencolor='blue', pensize=3)

Доступные ключи:

pendown — bool
pencolor — str или tuple
pensize — int ≥ 1
fillcolor — цвет заливки (см. ниже)
speed — int от 0 до 10 или строка
resizemode — 'auto', 'user', 'noresize'
stretchfactor — (x, y) масштаб формы черепашки
outline — ширина контура формы (int ≥ 0)
tilt — угол наклона формы относительно направления (float)

3. Состояние черепашки: сброс и возврат

Функция	Параметры	Описание
`home()`	—	Возвращает черепашку в центр `(0, 0)` и устанавливает направление `0°` (вправо). Оставляет след, если перо опущено.
`reset()`	—	Выполняет `home()`, сбрасывает все атрибуты черепашки к значениям по умолчанию (цвет — чёрный, размер — 1, форма — `'classic'`, видимость — `True`). Очищает холст, удаляет все штампы. Эквивалентно пересозданию черепашки.
`clear()`	—	Стирает все нарисованное этой черепашкой, не двигая её и не сбрасывая атрибуты. Штампы сохраняются.
`undo()`	—	Отменяет последнюю графическую команду (движение, поворот, цвет, размер). Максимум 1000 действий в буфере отмены.
`isvisible()`	—	Возвращает `True`, если черепашка видима.
`hideturtle()` `ht()`	—	Делает черепашку невидимой (форма не отображается). Движение и рисование продолжаются.
`showturtle()` `st()`	—	Делает черепашку видимой.

4. Управление видимостью и формой

Функция	Параметры	Описание
`shape(name=None)`	`name: str \| None`	Устанавливает форму черепашки. Допустимые имена: `'arrow'`, `'turtle'`, `'circle'`, `'square'`, `'triangle'`, `'classic'`, а также пользовательские имена, зарегистрированные через `Screen.register_shape()`. Без аргумента — возвращает имя текущей формы.
`shapesize(stretch_wid=None, stretch_len=None, outline=None)` `turtlesize(...)`	`stretch_wid, stretch_len: float`, `outline: int`	Масштабирует форму: – `stretch_wid` — вертикальный масштаб; – `stretch_len` — горизонтальный; – `outline` — ширина контура (в пикселях). Если параметры не заданы — возвращают текущие значения `(stretch_wid, stretch_len, outline)`.
`tilt(angle)`	`angle: float`	Поворачивает форму черепашки относительно её направления движения (визуальный наклон, не влияет на `heading()`).
`tiltangle(angle=None)`	`angle: float \| None`	Устанавливает абсолютный угол наклона формы. Без аргумента — возвращает текущий угол.
`get_shapepoly()`	—	Возвращает список `Vec2D` — координаты вершин текущей формы в её локальной системе координат (центрировано в `(0, 0)`). Полезно для отладки пользовательских фигур.

Пример: полный сброс и настройка

import turtle as t

t.shape('turtle')
t.color('darkgreen')        # эквивалентно pencolor + fillcolor
t.pensize(2)
t.speed('normal')
t.shapesize(1.2, 1.2, 2)    # чуть крупнее, контур 2px
t.tilt(15)                  # лёгкий наклон

Обратите внимание:

t.color(c) устанавливает одновременно pencolor(c) и fillcolor(c).
t.fillcolor(c) влияет только на цвет заливки внутри begin_fill()/end_fill().

4. Цвета, заливки и режимы цветового представления

1. Режимы цвета: `colormode()`

Модуль turtle поддерживает два режима представления RGB-цветов — глобальные для всего экрана.

Функция	Параметры	Описание
`colormode(cmode=None)`	`cmode: int \| None`	Устанавливает или возвращает текущий режим: – `1` — значения компонент в диапазоне `[0.0, 1.0]`; – `255` — значения в диапазоне `[0, 255]`. По умолчанию — `1`.

Примеры:

turtle.colormode(255)
t.pencolor(255, 100, 50)    # оранжево-красный

turtle.colormode(1.0)
t.pencolor(1.0, 0.4, 0.2)   # тот же цвет

Режим влияет на все функции, принимающие RGB:
pencolor(), fillcolor(), color(), bgcolor(), bgpic() (косвенно, при создании изображений).

2. Управление цветом пера и заливки

Функция	Параметры	Описание
`pencolor(*args)`	как в Части 3	Только для линий. Без аргументов — возвращает текущий цвет.
`fillcolor(*args)`	`*args: str \| tuple \| int`	Устанавливает цвет внутренней заливки замкнутых фигур. Поддерживает те же форматы, что и `pencolor()`.
`color(*args)`	комбинации аргументов	Комбинированная установка: – `color(c)` → `pencolor(c); fillcolor(c)`; – `color(pc, fc)` → `pencolor(pc); fillcolor(fc)`; – `color(r, g, b)` → `pencolor(r,g,b); fillcolor(r,g,b)`; – `color(pr, pg, pb, fr, fg, fb)` → `pencolor(pr,pg,pb); fillcolor(fr,fg,fb)`.

3. Заливка замкнутых фигур

Заливка применяется к замкнутым контурам, нарисованным между begin_fill() и end_fill().

Функция	Параметры	Описание
`begin_fill()`	—	Начинает запись контура для последующей заливки.
`end_fill()`	—	Завершает запись и выполняет заливку текущим `fillcolor()`, если контур замкнут (начальная и конечная точки совпадают или соединены линией).
`filling()`	—	Возвращает `True`, если сейчас активна запись контура (`begin_fill()` вызван, `end_fill()` — нет).

Важные правила заливки:

Контур должен быть простым (без самопересечений) для корректной заливки по алгоритму even-odd.
Если конец пути не совпадает с началом, черепашка соединяет их прямой линией (без следа, даже если перо поднято).
Пересечение контура приводит к частичной заливке (алгоритм winding rule не настраивается).

Пример: залитый треугольник

t.fillcolor("lightblue")
t.begin_fill()
for _ in range(3):
    t.forward(100)
    t.left(120)
t.end_fill()

4. Фон экрана

Функция	Параметры	Описание
`bgcolor(*args)`	как `pencolor()`	Устанавливает цвет фона холста. Применяется сразу.
`bgpic(picname=None)`	`picname: str \| None`	Устанавливает фоновое изображение. Допустимы: – `None` — убирает фон; – имя файла `.gif` (только GIF, без прозрачности); – `'nopic'` — отключает фон. Изображение центрируется, масштабируется под размер холста.

Поддержка форматов ограничена tkinter.PhotoImage, который принимает только GIF и PGM/PPM. Для PNG/JPEG требуется предварительная конвертация.

5. Стандартные имена цветов

turtle использует подмножество имён из X11/CSS3. Общее число — 147. Наиболее употребительные:

'white', 'black', 'red', 'green', 'blue', 'yellow', 'cyan', 'magenta',
'orange', 'purple', 'pink', 'brown', 'gray', 'lightgray', 'darkgray',
'navy', 'maroon', 'olive', 'teal', 'lime', 'aqua', 'fuchsia',
'silver', 'gold', 'indigo', 'violet', 'turquoise', 'coral', 'salmon',
'khaki', 'plum', 'orchid', 'crimson', 'tomato', 'sienna', 'tan'

Полный список доступен через:

import turtle
print(sorted(turtle._color_list()))  # внутренний метод, неофициальный

6. Градиенты (ручная реализация)

Модуль turtle не включает встроенную поддержку градиентов. Реализация возможна через:

Пошаговое изменение pencolor() в цикле (для линий и спиралей);
Рисование множества тонких штрихов с плавным изменением цвета (для заливки);
Использование tkinter.Canvas напрямую для создания градиентного фона.

Пример: спираль с градиентом

import turtle
from math import sin, cos, pi

t = turtle.Turtle()
t.speed(0)
turtle.colormode(255)

for i in range(360):
    r = int(127.5 * (1 + sin(i * pi / 180)))
    g = int(127.5 * (1 + cos(i * pi / 180)))
    b = 255 - r
    t.pencolor(r, g, b)
    t.forward(i * 0.3)
    t.left(59)

Этот приём — основа для визуализации функций, тепловых карт, радуг.

5. Экран, координаты, производительность

1. Инициализация и размеры экрана

Функция	Параметры	Описание
`setup(width=0.5, height=0.75, startx=None, starty=None)`	`width, height: int \| float`, `startx, starty: int \| None`	Инициализирует главное окно. Вызывается один раз — до любых действий с черепашкой. – Если `width`, `height` ∈ (0, 1) — доля от разрешения экрана. – Если ≥ 1 — размер в пикселях. – `startx`, `starty` — координаты левого верхнего угла окна на экране (`None` — центрирование).
`screensize(canvwidth=None, canvheight=None, bg=None)`	`canvwidth, canvheight: int`, `bg: str \| tuple`	Устанавливает размер холста (внутренней области прокрутки), не окна. По умолчанию — `400×300`. – Фон (`bg`) устанавливается только при наличии аргументов. – Превышение размера окна добавляет полосы прокрутки.

Примечание: setup() влияет на окно, screensize() — на рабочую область внутри окна.

2. Координатные системы

turtle поддерживает три режима координат:

Функция	Параметры	Описание
`mode(mode=None)`	`mode: str \| None`	Устанавливает или возвращает режим: – `'standard'` — 0° вправо, положительный поворот — против ЧС (`heading()` ∈ `[0, 360)`); – `'logo'` — 0° вверх, положительный поворот — по ЧС (`heading()` ∈ `[0, 360)`); – `'world'` — пользовательская система, устанавливается через `setworldcoordinates()`.
`setworldcoordinates(llx, lly, urx, ury)`	`llx, lly, urx, ury: float`	Переопределяет систему координат: – `(llx, lly)` — нижний левый угол; – `(urx, ury)` — верхний правый. Автоматически включает `mode('world')`. Полезно для графиков функций.

Пример: математическая система координат

screen = turtle.Screen()
screen.setworldcoordinates(-10, -10, 10, 10)
t.goto(5, 3)   # точка (5, 3) в декартовой плоскости

3. Размеры экрана и позиция

Функция	Параметры	Описание
`window_width()`	—	Возвращает ширину окна в пикселях (`int`).
`window_height()`	—	Возвращает высоту окна в пикселях (`int`).
`canvwidth`, `canvheight`	—	Атрибуты объекта `Screen()`: ширина и высота холста (не окна).

4. Управление анимацией и производительностью

Функция	Параметры	Описание
`tracer(n=None, delay=None)`	`n: int \| None`, `delay: int \| None`	Управляет автообновлением холста: – `tracer(0)` — отключает автообновление (режим пакетной отрисовки); – `tracer(n)` — обновление каждые `n` действий; – `delay` — задержка в мс между кадрами (по умолчанию — 10 мс при `n=1`).
`update()`	—	Принудительно обновляет холст. Обязателен после `tracer(0)` для отображения изменений.
`delay(ms)`	`ms: int`	Устанавливает минимальную задержку между кадрами (в мс). Не влияет на `tracer(0)`.
`speed(s)`	`s: int \| str`	Как в Части 2 — управляет скоростью анимации движения, но не отменяет `tracer()`. При `tracer(0)` `speed()` игнорируется.

Рекомендация по оптимизации:
Для сложных рисунков (тысячи линий) используйте:

screen = turtle.Screen()
screen.tracer(0)     # отключить анимацию
# ... рисование ...
screen.update()      # один раз отобразить результат

Это ускоряет отрисовку в десятки–сотни раз.

5. Заголовок и иконка

Функция	Параметры	Описание
`title(titlestring)`	`titlestring: str`	Устанавливает заголовок окна.
`turtle.iconbitmap(bitmap)`	`bitmap: str`	Устанавливает иконку окна (`.ico` или `.xbm`). Работает не во всех ОС.

6. Таймер и обновление по времени

Функция	Параметры	Описание
`ontimer(fun, t=0)`	`fun: callable`, `t: int`	Запускает функцию `fun` через `t` миллисекунд. Не блокирует выполнение. Поддерживает рекурсивный вызов для анимации.

Пример: мигающий квадрат

def blink():
    t.fillcolor('red' if t.fillcolor() == 'white' else 'white')
    t.clear()
    t.begin_fill()
    for _ in range(4): t.fd(50); t.rt(90)
    t.end_fill()
    screen.ontimer(blink, 500)

screen.ontimer(blink, 500)

6. События, взаимодействие и ввод данных

Модуль turtle поддерживает реакцию на действия пользователя: щелчки мышью, нажатия клавиш, перетаскивание. Все обработчики работают в основном потоке и не прерывают выполнение — вызовы ставятся в очередь событий tkinter.

1. Обработка событий мыши

Функция	Параметры	Описание
`onclick(fun, btn=1, add=None)`	`fun: callable(x, y)`, `btn: int`, `add: bool \| None`	Регистрирует функцию `fun`, вызываемую при щелчке по черепашке. – `btn`: 1 — левая, 2 — средняя, 3 — правая кнопка. – `fun` получает координаты точки клика в системе холста. – `add=False` (по умолчанию) заменяет существующий обработчик; `add=True` — добавляет.
`onscreenclick(fun, btn=1, add=None)`	`fun: callable(x, y)`	Регистрирует функцию, вызываемую при щелчке в любом месте холста (не только по черепашке).
`ondrag(fun, btn=1, add=None)`	`fun: callable(x, y)`	Регистрирует функцию, вызываемую при перетаскивании черепашки с зажатой кнопкой `btn`. – Черепашка автоматически перемещается в точку `(x, y)` перед вызовом `fun`, если `turtle.ondrag()` вызван у объекта черепашки. – Чтобы предотвратить автоматическое перемещение — используйте `t.ondrag(None)` внутри `fun` и управляйте позицией вручную.
`onrelease(fun, btn=1, add=None)`	`fun: callable(x, y)`	Регистрирует функцию при отпускании кнопки мыши над черепашкой.

Обратите внимание:
– Для включения обработки событий обязательно вызвать screen.listen() один раз.
– Функции-обработчики не должны содержать блокирующих операций (например, time.sleep()).

Пример: черепашка следует за мышью

def drag_handler(x, y):
    t.ondrag(None)      # отключить рекурсию
    t.goto(x, y)
    t.ondrag(drag_handler)

t.ondrag(drag_handler)
screen.listen()

2. Обработка нажатий клавиш

Функция	Параметры	Описание
`onkey(fun, key)` `onkeyrelease(fun, key)`	`fun: callable()`, `key: str`	Регистрирует `fun` при отпускании клавиши `key`.
`onkeypress(fun, key=None)`	`fun: callable()`, `key: str \| None`	Регистрирует `fun` при нажатии клавиши. Если `key=None` — срабатывает на любую клавишу.
`listen()`	—	Включает прослушивание клавиатурных и мышиных событий. Без этого вызова обработчики не активируются.

Поддерживаемые значения key:

Одиночные символы: 'a', 'A', '1', ' ' (пробел)
Специальные клавиши: 'Up', 'Down', 'Left', 'Right', 'Escape', 'Return', 'Tab', 'Delete', 'BackSpace'
Комбинации: 'Shift_L', 'Control_R', 'Alt_L' (но без модификаторов в fun)

Пример: управление стрелками

def go_forward(): t.fd(10)
def turn_left():  t.lt(15)
def turn_right(): t.rt(15)

screen.onkey(go_forward, 'Up')
screen.onkey(turn_left,  'Left')
screen.onkey(turn_right, 'Right')
screen.listen()

3. Диалоговые окна ввода

Функция	Параметры	Описание
`textinput(title, prompt)`	`title, prompt: str`	Открывает модальное окно с полем ввода текста. Возвращает `str` или `None` (если отмена).
`numinput(title, prompt, default=None, minval=None, maxval=None)`	`title, prompt: str`, `default: float \| None`, `minval, maxval: float \| None`	Открывает окно ввода числа. Проверяет диапазон. Возвращает `float` или `None`.

Пример: настройка параметров

n = screen.numinput("Многоугольник", "Число сторон:", 5, minval=3, maxval=20)
if n is not None:
    for _ in range(int(n)):
        t.fd(100)
        t.rt(360 / n)

Эти функции блокируют выполнение до закрытия окна. Подходят для инициализации, но не для игровых циклов.

4. Мышь и холст: дополнительные функции

Функция	Параметры	Описание
`getcanvas()`	—	Возвращает внутренний `tkinter.Canvas`. Позволяет использовать низкоуровневые методы: `create_line`, `create_polygon`, `itemconfig` и т.д.
`getshapes()`	—	Возвращает список имён зарегистрированных форм (встроенных и пользовательских).
`setundobuffer(size)`	`size: int \| None`	Устанавливает размер буфера отмены (`undo()`). Максимум — 1000. `size=None` — отключает отмену.

Пример: прямая работа с Canvas

canvas = screen.getcanvas()
canvas.create_text(0, -200, text="Готово!", fill="blue", font=("Arial", 16))

7. Пользовательские формы, штампы и изображения

1. Регистрация пользовательских форм

Формы черепашек определяются через класс turtle.Shape. Поддерживаются два типа:

'polygon' — многоугольник из списка вершин;
'image' — растровое изображение (только .gif).

Функция	Параметры	Описание
`register_shape(name, shape=None)`	`name: str`, `shape: str \| Shape \| list[Vec2D]`	Регистрирует новую форму под именем `name`: – `shape` — строка (путь к `.gif`); – `shape` — список `(x, y)` (автоматически создаёт `Shape('polygon', ...)`); – `shape` — экземпляр `turtle.Shape`.
`addshape(name, shape=None)`	—	Синоним `register_shape()`.

Тип `'polygon'`

Форма задаётся списком вершин в локальной системе координат черепашки:

Центр масс должен быть в (0, 0) для корректного поворота.
Координаты — в пикселях, независимо от colormode.
Порядок вершин — по часовой или против; заливка работает по правилу even-odd.

Пример: звезда

star = [(0, 15), (4, 5), (13, 5), (6, 0), (9, -6),
        (0, -2), (-9, -6), (-6, 0), (-13, 5), (-4, 5)]
screen.register_shape("star", star)
t.shape("star")

Тип `'image'`

Поддерживается только формат GIF. Прозрачность работает, если GIF содержит альфа-канал (в формате GIF89a).

Требования:

Файл должен существовать и быть доступен для чтения.
Имя файла — относительно рабочей директории или абсолютный путь.
После регистрации изображение кэшируется — изменение файла не обновляет форму.

Пример:

screen.register_shape("ship.gif")  # файл в текущей папке
t.shape("ship.gif")

Важно: tkinter (а значит и turtle) не поддерживает PNG, JPEG, SVG напрямую. Конвертация в GIF обязательна.

2. Класс `turtle.Shape`

Конструктор:

shape = turtle.Shape(type_, data)

type_: 'polygon' или 'image'
data:
– при 'polygon' — список (x, y) или Vec2D;
– при 'image' — строка, путь к .gif.

После создания форма неактивна, пока не зарегистрирована:

s = turtle.Shape("polygon", [(0,10), (-5,-5), (5,-5)])
screen.register_shape("triangle", s)
t.shape("triangle")

3. Штампы (`stamp`)

Штамп — статичная копия формы черепашки в текущей позиции, повороте и цвете. Не привязан к черепашке после создания.

Функция	Параметры	Описание
`stamp()`	—	Создаёт штамп. Возвращает уникальный целочисленный ID (`int`).
`clearstamp(stampid)`	`stampid: int`	Удаляет штамп с указанным ID.
`clearstamps(n=None)`	`n: int \| None`	Удаляет штампы: – `n > 0` — последние `n`; – `n < 0` — первые `
`stampItems`	—	Внутренний атрибут экземпляра `Turtle`: список ID всех штампов, созданных этой черепашкой. Не рекомендуется использовать напрямую.

Особенности:

Штамп сохраняет цвета pencolor и fillcolor на момент вызова stamp().
Изменение формы или цвета черепашки не влияет на уже созданные штампы.
Штампы не удаляются при clear() — только clearstamp()/clearstamps() или reset().

Пример: снежинка из штампов

t.shape("circle")
t.shapesize(0.3)
for _ in range(50):
    t.goto(random.randint(-300, 300), random.randint(-200, 200))
    t.stamp()

4. Получение и анализ форм

Функция	Параметры	Описание
`get_shapepoly()`	—	Возвращает список `Vec2D` — вершины текущей формы в локальных координатах. Только для `'polygon'`. Для `'image'` возвращает `None`.
`getshapes()`	—	Возвращает список имён всех зарегистрированных форм (встроенных и пользовательских).

Пример: проверка формы

poly = t.get_shapepoly()
if poly:
    print(f"Форма — многоугольник из {len(poly)} вершин")

5. Рекомендации по созданию форм

Для симметричных фигур (стрелка, корабль) располагайте нос в (0, 0), хвост — отрицательный Y.

Используйте Vec2D для точных расчётов:

from turtle import Vec2D
v = Vec2D(10, 0).rotate(30)  # (8.66, 5.0)

Избегайте самопересекающихся полигонов — заливка может работать некорректно.
При масштабировании (shapesize) пропорции сохраняются; для асимметричного растяжения задавайте stretch_wid ≠ stretch_len.

8. Настройки отображения, анимация и интеграция в GUI

1. Взаимодействие `tracer()`, `delay()` и `speed()`

Эти параметры управляют частотой обновления экрана и плавностью движения, но действуют на разных уровнях.

Параметр	Уровень	Влияние	Типичное применение
`tracer(n, delay)`	`Screen`	Контролирует, когда холст перерисовывается: – `n = 0`: ручное обновление (`update()`); – `n > 0`: автообновление каждые `n` графических команд; – `delay`: минимальная пауза между кадрами (мс).	Массовая отрисовка (фракталы, диаграммы).
`delay(ms)`	`Screen`	Задаёт фиксированную задержку после каждого обновления экрана. Перекрывается `tracer(n, delay)`, если указан явно.	Упрощённое замедление без изменения `tracer`.
`speed(s)`	`Turtle`	Определяет, как быстро черепашка проходит путь между точками: – `0` (`'fastest'`): мгновенное перемещение (анимация отключена); – `1..10`: интерполяция через промежуточные кадры.	Обучение, демонстрации, игры.

Правила приоритета:

При tracer(0) анимация движения (speed()) игнорируется — черепашка телепортируется.
При tracer(n>0) и speed(0) черепашка также телепортируется, но холст обновляется каждые n шагов.
delay() применяется после update(), даже при tracer(0).

Пример: плавная анимация без мерцания

screen.tracer(1, 50)   # обновлять каждый кадр, задержка 50 мс
t.speed(6)             # нормальная скорость движения
for _ in range(36):
    t.circle(50)
    t.right(10)
# Каждый поворот — один кадр с задержкой

2. Прямой доступ к `tkinter`

turtle построен на tkinter.Canvas. Получение низкоуровневого доступа позволяет:

Рисовать субпиксельно точные примитивы (create_line, create_oval)
Добавлять текст, изображения, градиенты
Привязывать события к элементам холста
Встраивать turtle в существующее tkinter-приложение

Метод	Возвращаемое значение	Применение
`screen.getcanvas()`	`tkinter.Canvas`	Основной холст, на котором работает `turtle`.
`screen.cv`	`tkinter.Canvas`	Синоним `getcanvas()` (устаревшее, но рабочее).
`screen._canvas`	`tkinter.Canvas`	Внутренний атрибут (неофициальный, но стабильный).

Пример: градиентный фон через Canvas

canvas = screen.getcanvas()
width, height = screen.window_width(), screen.window_height()

for i in range(height):
    r = int(255 * i / height)
    g = 100
    b = 255 - r
    color = f"#{r:02x}{g:02x}{b:02x}"
    canvas.create_line(0, i, width, i, fill=color)

3. Интеграция в `tkinter`: `TurtleScreen` и `RawTurtle`

Для встраивания черепашьей графики в GUI-приложение:

Создать tkinter.Tk() и tkinter.Canvas.
Обернуть Canvas в turtle.TurtleScreen.
Создать turtle.RawTurtle, привязанную к этому TurtleScreen.

Пример: встраивание в окно с кнопками

import tkinter as tk
import turtle

root = tk.Tk()
root.title("Turtle in Tkinter")

# Верхняя панель
frame = tk.Frame(root)
frame.pack(side=tk.TOP)

def draw_square():
    t.clear()
    for _ in range(4):
        t.fd(100); t.rt(90)

btn = tk.Button(frame, text="Квадрат", command=draw_square)
btn.pack(side=tk.LEFT)

# Холст
canvas = tk.Canvas(root, width=600, height=400)
canvas.pack()

# Интеграция turtle
ts = turtle.TurtleScreen(canvas)
ts.bgcolor("white")
t = turtle.RawTurtle(ts)
t.speed(0)

root.mainloop()

Преимущества:

Полный контроль над окном;
Возможность комбинировать turtle с другими виджетами;
Несколько независимых TurtleScreen в одном приложении.

4. Производительность и ограничения

Лимит штампов: ~10⁵ на экране (зависит от ОС и видеопамяти).
Лимит линий: ~10⁴–10⁵ примитивов до заметного замедления.
Максимум черепашек: нет жёсткого лимита, но >1000 вызывает падение FPS.
Память: каждый штамп хранит изображение; при tracer(0) временно кэшируются команды.

Оптимизации:

Использовать tracer(0) + update() в конце.
Заменять тысячи маленьких circle() на один canvas.create_oval().
Отключать undo через setundobuffer(0), если не нужен.
Для анимаций — пересчитывать только изменившиеся части.

5. Отладка и инспекция

Инструмент	Описание
`print(t)`	Показывает: позиция, направление, состояние пера, видимость.
`t.__dict__`	Полный словарь атрибутов объекта (`_position`, `_angle`, `_pencolor` и др.).
`screen.cv.postscript(file="out.eps")`	Экспорт в векторный формат EPS (через PostScript).
`turtle._CFG`	Внутренний словарь конфигурации по умолчанию (`width`, `height`, `startx`, и т.д.).

Пример: экспорт в PDF (через EPS + внешний конвертер)

screen.cv.postscript(file="drawing.eps")
# Затем: eps2pdf drawing.eps drawing.pdf (внешняя утилита)

Прямой экспорт в PNG/SVG невозможен средствами turtle. Требуется PIL или cairo.

9. Вспомогательные функции, математика и служебные инструменты

1. Угловые единицы измерения

Функция	Параметры	Описание
`degrees(fullcircle=360.0)`	`fullcircle: float`	Устанавливает полный угол в градусах. По умолчанию — 360°. Влияет на `heading()`, `setheading()`, `circle()`, `left()`, `right()`.
`radians()`	—	Устанавливает полный угол в `2π` радиан. После вызова все угловые функции работают в радианах.

Важно:

Переключение меняет все угловые операции глобально — для всего экрана.
towards(), heading() возвращают значения в текущей системе.
circle() интерпретирует extent в текущих единицах.

Пример: тригонометрическая спираль в радианах

import math
turtle.radians()
t.speed(0)

for i in range(1, 300):
    angle = i * 0.1
    radius = i * 0.5
    x = radius * math.cos(angle)
    y = radius * math.sin(angle)
    t.goto(x, y)

2. Вывод текста

Функция	Параметры	Описание
`write(arg, move=False, align="left", font=("Arial", 8, "normal"))`	`arg: object`, `move: bool`, `align: str`, `font: tuple`	Выводит текст в текущей позиции черепашки: – `arg` преобразуется в `str`; – `move=True` — черепашка перемещается в конец строки; – `align`: `'left'`, `'center'`, `'right'`; – `font`: `(название, размер, стиль)`, стиль — `'normal'`, `'bold'`, `'italic'`, `'bold italic'`.

Поддерживаемые шрифты:
Зависят от системы. Гарантированно работают: 'Arial', 'Courier', 'Times', 'Helvetica', 'System'.

Особенности:

Текст не является частью пути — не участвует в заливке, не стирается clear().
Координата привязки — нижний левый угол (при align='left').
Размер шрифта — в пунктах, не пикселях.

Пример: подпись осей

t.penup()
t.goto(-200, 0); t.write("← X", align="center")
t.goto(0, 150); t.write("Y ↑", align="center")

3. Математические и геометрические функции

Функция	Параметры	Описание
`distance(x, y=None)`	`x: float \| tuple \| Turtle`, `y: float \| None`	Возвращает евклидово расстояние от черепашки до точки `(x, y)` или другой черепашки. Эквивалент `abs(t.pos() - target.pos())`.
`towards(x, y=None)`	как `distance()`	Возвращает угол направления от черепашки к цели в текущих угловых единицах.
`xcor()`, `ycor()`, `pos()`, `heading()`	—	Возвращают координаты и угол как `float` или `Vec2D`.
`Vec2D(x, y)`	`x, y: float`	Класс вектора. Поддерживает: – Арифметику: `v1 + v2`, `v * scalar`, `-v`; – Скалярное произведение: `v1 * v2`; – Длину: `abs(v)`; – Поворот: `v.rotate(angle)`; – Угол: `v.angle(v2)` — угол между векторами.

Пример: отражение от границ

def reflect():
    x, y = t.pos()
    w, h = screen.window_width()/2, screen.window_height()/2
    if abs(x) > w or abs(y) > h:
        t.right(180 - 2 * t.heading())  # упрощённая модель

4. Диалоги и ввод (дополнение к Части 6)

Функция	Параметры	Поведение
`textinput(title, prompt)`	—	Блокирующий вызов. Возвращает `str` или `None`. Использует `tkSimpleDialog.askstring`.
`numinput(title, prompt, default, minval, maxval)`	—	Блокирующий вызов. Проверяет диапазон и числовую валидность. Возвращает `float` или `None`.

Эти функции не работают в средах без GUI (например, Jupyter Notebook без turtle-расширения, CI/CD). Для веб-интеграции требуется замена на HTML-диалоги.

5. Состояние и проверки

Функция	Возвращает	Описание
`isdown()`	`bool`	`True`, если перо опущено.
`isvisible()`	`bool`	`True`, если черепашка видима.
`filling()`	`bool`	`True`, если активна запись контура (`begin_fill()` вызван).
`screen.window_width()`	`int`	Текущая ширина окна в пикселях.
`screen.window_height()`	`int`	Текущая высота окна в пикселях.

6. Константы и служебные значения

turtle не экспортирует математических констант. Используйте модуль math:

import math
print(math.pi, math.e, math.tau)  # 3.1415..., 2.7182..., 6.2831...

Доступные через turtle:

turtle.version — строка, например '3.10.0'
turtle.TERMINATOR — исключение, возникающее при закрытии окна
turtle.Vec2D — класс вектора

7. Обработка завершения

Функция	Параметры	Описание
`done()` `mainloop()`	—	Запускает цикл событий `tkinter`. Обязателен в скриптах вне IDLE. Без него окно закрывается сразу.
`bye()`	—	Корректно завершает работу: закрывает окно, освобождает ресурсы.
`exitonclick()`	—	Регистрирует `bye()` на щелчок по холсту, затем запускает `mainloop()`.

Рекомендация для скриптов:

# В конце программы
screen.exitonclick()  # или
# turtle.done()

10. Примеры фигур

1. Квадрат

def square(size=100):
    for _ in range(4):
        t.fd(size)
        t.rt(90)

Использует 4 отрезка и поворот на 90°.
Альтернатива: t.circle(size/2, steps=4).

2. Равносторонний треугольник

def equilateral_triangle(side=100):
    for _ in range(3):
        t.fd(side)
        t.rt(120)

Внешний угол = 180° − 60° = 120°.
Альтернатива: t.circle(side / (3**0.5), steps=3) (радиус описанной окружности = a / √3).

3. Прямоугольник

def rectangle(width=120, height=80):
    for _ in range(2):
        t.fd(width)
        t.rt(90)
        t.fd(height)
        t.rt(90)

4. Правильный N-угольник

def regular_polygon(n, side=50):
    if n < 3:
        raise ValueError("n >= 3")
    angle = 360 / n
    for _ in range(n):
        t.fd(side)
        t.rt(angle)

Универсально для любого n ≥ 3.
При n → ∞ приближается к окружности.

5. Домик

def house(size=100):
    # Стены
    t.begin_fill()
    t.fillcolor("lightgray")
    for _ in range(4):
        t.fd(size)
        t.rt(90)
    t.end_fill()
    
    # Крыша
    t.fillcolor("brown")
    t.begin_fill()
    t.lt(60)
    t.fd(size)
    t.rt(120)
    t.fd(size)
    t.rt(120)
    t.fd(size)
    t.end_fill()
    t.lt(180)  # возврат направления
    
    # Дверь
    t.penup()
    t.goto(size * 0.35, 0)
    t.pendown()
    t.fillcolor("saddlebrown")
    t.begin_fill()
    for _ in range(2):
        t.fd(size * 0.3)
        t.lt(90)
        t.fd(size * 0.5)
        t.lt(90)
    t.end_fill()
    
    # Окно
    t.penup()
    t.goto(size * 0.6, size * 0.6)
    t.pendown()
    t.fillcolor("cyan")
    t.begin_fill()
    for _ in range(4):
        t.fd(size * 0.2)
        t.rt(90)
    t.end_fill()

Использует абсолютное позиционирование (goto) для деталей.
Заливки разными цветами.

6. Цветок (4 лепестка)

def flower(petal_radius=50, petals=6):
    t.pencolor("purple")
    for _ in range(petals):
        t.circle(petal_radius, 60)
        t.lt(120)
        t.circle(petal_radius, 60)
        t.lt(120)
        t.rt(360 / petals)

Каждый лепесток — две дуги по 60° с поворотом 120° между ними.
Общее вращение на 360/petals после лепестка.

7. Спираль Архимеда

def archimedean_spiral(a=5, turns=5):
    t.penup()
    t.goto(0, 0)
    t.pendown()
    for i in range(turns * 360):
        r = a * (i * 0.0174533)  # i в радианах
        x = r * math.cos(math.radians(i))
        y = r * math.sin(math.radians(i))
        t.goto(x, y)

Формула: r = a·θ, θ в радианах.
Шаг 0.0174533 = π/180 — конвертация градусов в радианы.

8. Логарифмическая спираль

def logarithmic_spiral(a=0.1, b=0.2, turns=5):
    for i in range(turns * 360):
        theta = math.radians(i)
        r = a * math.exp(b * theta)
        x = r * math.cos(theta)
        y = r * math.sin(theta)
        t.goto(x, y)

Формула: r = a·e^(b·θ).
Характерна для раковин, галактик.

9. Снежинка Коха (рекурсивная, глубина 3)

def koch_curve(length, depth):
    if depth == 0:
        t.fd(length)
    else:
        koch_curve(length / 3, depth - 1)
        t.lt(60)
        koch_curve(length / 3, depth - 1)
        t.rt(120)
        koch_curve(length / 3, depth - 1)
        t.lt(60)
        koch_curve(length / 3, depth - 1)

def koch_snowflake(size=200, depth=3):
    t.penup()
    t.goto(-size / 2, size / 3**0.5 / 2)
    t.pendown()
    for _ in range(3):
        koch_curve(size, depth)
        t.rt(120)

Глубина 0 — отрезок; 1 — «горка»; 2+ — фрактал.
Начальная позиция центрирует снежинку.

10. Дракон Хартера-Хейтуэя (итеративный, 12 итераций)

def dragon_curve(iterations=12):
    # Направления: 0=вправо, 1=вверх, 2=влево, 3=вниз
    turns = []
    for i in range(iterations):
        rev = [1 - x for x in reversed(turns)]  # инверсия
        turns = turns + [0] + rev
    
    t.fd(5)
    for turn in turns:
        if turn == 0:
            t.rt(90)
        else:
            t.lt(90)
        t.fd(5)

Построение через последовательность поворотов.
iterations=12 даёт ~4000 сегментов — требуется tracer(0).

11. Часы с движущимися стрелками

import time

def draw_clock():
    # Циферблат
    t.penup()
    t.goto(0, -150)
    t.pendown()
    t.circle(150)
    
    # Чёрточки часов
    for _ in range(12):
        t.penup()
        t.fd(130)
        t.pendown()
        t.fd(20)
        t.penup()
        t.goto(0, 0)
        t.rt(30)

def clock_hands():
    # Получаем время
    lt = time.localtime()
    h, m, s = lt.tm_hour % 12, lt.tm_min, lt.tm_sec
    
    # Часовая стрелка
    t.penup(); t.goto(0, 0); t.setheading(90)
    t.rt(30 * h + 0.5 * m); t.pendown()
    t.pensize(5); t.fd(60)
    
    # Минутная
    t.penup(); t.goto(0, 0); t.setheading(90)
    t.rt(6 * m); t.pendown()
    t.pensize(3); t.fd(90)
    
    # Секундная
    t.penup(); t.goto(0, 0); t.setheading(90)
    t.rt(6 * s); t.pendown()
    t.pencolor("red"); t.pensize(1); t.fd(100)

# Анимация
draw_clock()
while True:
    t.clear()
    draw_clock()
    clock_hands()
    screen.update()
    time.sleep(1)

Обновление каждую секунду.
Использует clear() и повторную отрисовку.

12. Простая солнечная система (2D, без физики)

def solar_system():
    # Солнце
    t.penup(); t.goto(0, 0); t.dot(50, "yellow")
    
    # Планеты по орбитам
    orbits = [
        (30, "gray", 0.02),     # Меркурий
        (50, "tan", 0.015),     # Венера
        (75, "blue", 0.01),     # Земля
        (100, "red", 0.008),    # Марс
    ]
    
    angles = [0, 45, 90, 135]
    for i, (r, color, speed) in enumerate(orbits):
        angle = angles[i]
        x = r * math.cos(math.radians(angle))
        y = r * math.sin(math.radians(angle))
        t.penup(); t.goto(x, y)
        t.dot(10, color)
        angles[i] += speed * 180 / math.pi  # обновление угла

Циклический вызов solar_system() через ontimer() даёт анимацию.
Упрощённая модель: круговые орбиты, постоянная угловая скорость.

11. Рекомендации по проектированию, отладке и расширению

1. Структурирование кода

Для обучающих программ и небольших демонстраций:

Используйте процедурный интерфейс (import turtle as t).
Группируйте действия в функции: draw_house(), draw_tree().
Параметризуйте: размер, цвет, позиция — аргументы функций.
Избегайте глобальных переменных — передавайте t и screen явно при масштабировании.

Для сложных проектов (игры, симуляции, GUI):

Применяйте ООП: создавайте классы Planet, Robot, Graph, содержащие RawTurtle как поле.
Разделяйте логику и отрисовку: метод update_state() и render().
Управляйте несколькими черепашками через списки или словари.

Пример класса:

class Walker:
    def __init__(self, screen, color="black"):
        self.t = turtle.RawTurtle(screen)
        self.t.shape("turtle")
        self.t.color(color)
        self.t.speed(0)
    
    def step(self, dist=10):
        self.t.fd(dist)
    
    def turn_random(self, angle_range=30):
        self.t.rt(random.uniform(-angle_range, angle_range))

2. Отладка и визуальный контроль

Метод	Применение
`t.dot(5, "red")` после ключевых `goto()`	Визуальное подтверждение точек пути.
`print(f"{t.pos()=}, {t.heading()=}")` в циклах	Контроль состояния без изменения графики.
`t.speed(1)` + `screen.tracer(1, 100)`	Пошаговая анимация для выявления ошибок поворотов.
Временное `t.shape("arrow")`	Чёткое отображение направления (в отличие от `"turtle"`).
`screen.delay(200)`	Искусственное замедление для наблюдения за порядком действий.

Рекомендация:
Всегда завершайте контур begin_fill()/end_fill() явным возвратом в начальную точку — это устраняет артефакты заливки при неточных расчётах.

3. Экспорт графики

turtle не поддерживает прямой экспорт в PNG/SVG, но возможны обходные пути.

3.1. EPS → PDF/PNG

# Сохранение в EPS
canvas = screen.getcanvas()
canvas.postscript(file="output.eps")

# Конвертация внешними средствами:
#   eps2pdf output.eps output.pdf
#   convert output.eps output.png   # ImageMagick

EPS — векторный формат, масштабируется без потерь.
Текст в write() экспортируется как кривые Безье (не редактируемый текст).

3.2. Скриншот через PIL

import PIL.ImageGrab

# Только Windows/macOS
screen.setup(800, 600)
screen.update()
x0 = screen.cv.winfo_rootx()
y0 = screen.cv.winfo_rooty()
x1 = x0 + screen.cv.winfo_width()
y1 = y0 + screen.cv.winfo_height()
PIL.ImageGrab.grab(bbox=(x0, y0, x1, y1)).save("screenshot.png")

winfo_width()/height() возвращают размер холста, не окна.
На Linux используйте gnome-screenshot или pyscreenshot.

3.3. Анимация в GIF

Соберите кадры через tracer(1) + canvas.postscript() в цикле, затем объедините через PIL.Image:

from PIL import Image

frames = []
for i in range(36):
    t.rt(10)
    screen.update()
    canvas.postscript(file=f"frame_{i:02}.eps")
    # Конвертируем EPS → PNG → добавляем в frames
# Image.save("anim.gif", save_all=True, append_images=frames, duration=100)

Трудоёмко, но даёт плавную анимацию.

4. Интеграция с другими библиотеками

Библиотека	Возможности	Пример применения
`matplotlib`	Совместное отображение графиков и черепашьей графики	Визуализация траектории + график функции в одном `tkinter`-окне.
`opencv`	Захват экрана, обработка изображений	Автоматический анализ нарисованных фигур (распознавание многоугольников).
`numpy`	Векторные вычисления для спиралей, фракталов	`x = r * np.cos(theta)` с векторизацией для ускорения.
`pandas`	Чтение данных → визуализация	Построение траектории по GPS-треку из CSV.

Пример: matplotlib + turtle в одном окне

import tkinter as tk
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
import matplotlib.pyplot as plt

root = tk.Tk()
fig, ax = plt.subplots()
ax.plot([0,1,2], [0,1,0])
canvas_mpl = FigureCanvasTkAgg(fig, root)
canvas_mpl.get_tk_widget().pack(side=tk.LEFT)

canvas_turtle = tk.Canvas(root, width=400, height=300)
canvas_turtle.pack(side=tk.RIGHT)
ts = turtle.TurtleScreen(canvas_turtle)
t = turtle.RawTurtle(ts)
t.circle(50)

5. Ограничения `turtle` и переход к другим инструментам

Ограничение	Альтернатива	Преимущество
Только 2D, без текстур, теней	`pygame`, `arcade`, `ursina`	Полноценная 2D/3D графика, физика, звук.
Нет поддержки шрифтов вне `tkinter`	`pygame.font`, `PIL.ImageDraw`	Кастомные шрифты, Unicode, рендеринг в изображения.
Медленная отрисовка >10⁵ примитивов	`matplotlib` (line collections), `vispy`	Векторная/OpenGL-ускоренная визуализация.
Отсутствие веб-вывода	`p5`, `manim`, `three.js`	Интерактивные веб-демонстрации.
Нет поддержки анимаций по ключевым кадрам	`manim`	Математические анимации высокого качества (как в 3Blue1Brown).

Когда оставаться в turtle:

Обучение основам программирования (8–16 лет);
Быстрые прототипы геометрических идей;
Визуализация рекурсии, фракталов, алгоритмов обхода;
Интеграция в документацию (Docusaurus, Sphinx) через статичные изображения.

6. Лучшие практики

Всегда вызывайте screen.tracer(0) и screen.update() для сложных рисунков.
Используйте with для временного изменения состояния:
```
def with_penup(func):
    t.penup()
    func()
    t.pendown()
```
Храните настройки в dict и восстанавливайте через t.pen(old_state).
Для повторного использования — оформляйте фигуры как модули (shapes.py, fractals.py).
Проверяйте версию: turtle в Python 3.6+ стабилен; в 2.7 — устаревший.

Справочник по модулю Turtle​

1. Введение и основные классы модуля turtle​

Основные классы​

1. turtle.Turtle​

2. turtle.Screen​

3. turtle.TurtleScreen​

4. turtle.RawTurtle​

5. turtle.Vec2D​

6. turtle.Shape​

2. Функции управления движением​

1. Линейное перемещение​

2. Повороты​

3. Криволинейное движение​

4. Ограничение движения​

Особенности circle() — ключевая функция​

3. Управление пером и состоянием черепашки​

1. Основные функции управления пером​

2. Расширенное управление пером через pen()​

3. Состояние черепашки: сброс и возврат​

4. Управление видимостью и формой​

Пример: полный сброс и настройка​

4. Цвета, заливки и режимы цветового представления​

1. Режимы цвета: colormode()​

2. Управление цветом пера и заливки​

3. Заливка замкнутых фигур​

4. Фон экрана​

5. Стандартные имена цветов​

6. Градиенты (ручная реализация)​

5. Экран, координаты, производительность​

1. Инициализация и размеры экрана​

2. Координатные системы​

3. Размеры экрана и позиция​

4. Управление анимацией и производительностью​

5. Заголовок и иконка​

6. Таймер и обновление по времени​

6. События, взаимодействие и ввод данных​

1. Обработка событий мыши​

2. Обработка нажатий клавиш​

3. Диалоговые окна ввода​

4. Мышь и холст: дополнительные функции​

7. Пользовательские формы, штампы и изображения​

1. Регистрация пользовательских форм​

Тип 'polygon'​

Тип 'image'​

2. Класс turtle.Shape​

3. Штампы (stamp)​

4. Получение и анализ форм​

5. Рекомендации по созданию форм​

8. Настройки отображения, анимация и интеграция в GUI​

1. Взаимодействие tracer(), delay() и speed()​

2. Прямой доступ к tkinter​

3. Интеграция в tkinter: TurtleScreen и RawTurtle​

4. Производительность и ограничения​

5. Отладка и инспекция​

9. Вспомогательные функции, математика и служебные инструменты​

1. Угловые единицы измерения​

2. Вывод текста​

3. Математические и геометрические функции​

4. Диалоги и ввод (дополнение к Части 6)​

5. Состояние и проверки​

6. Константы и служебные значения​

7. Обработка завершения​

10. Примеры фигур​

1. Квадрат​

2. Равносторонний треугольник​

3. Прямоугольник​

4. Правильный N-угольник​

5. Домик​

6. Цветок (4 лепестка)​

7. Спираль Архимеда​

8. Логарифмическая спираль​

9. Снежинка Коха (рекурсивная, глубина 3)​

10. Дракон Хартера-Хейтуэя (итеративный, 12 итераций)​

11. Часы с движущимися стрелками​

12. Простая солнечная система (2D, без физики)​

11. Рекомендации по проектированию, отладке и расширению​

1. Структурирование кода​

2. Отладка и визуальный контроль​

3. Экспорт графики​

3.1. EPS → PDF/PNG​